Testing and Debugging with Guava

Google Guava শুধু Java অ্যাপ্লিকেশন ডেভেলপমেন্টের জন্য পারফরম্যান্স বাড়ানোর টুলস প্রদান করে না, বরং Testing এবং Debugging-এর ক্ষেত্রেও বেশ কার্যকর ভূমিকা রাখে। এখানে Guava-র সাহায্যে টেস্টিং এবং ডিবাগিংয়ের জন্য কিছু কার্যকর কৌশল ও Best Practices তুলে ধরা হলো:

Testing with Guava

১. Preconditions for Input Validation

Guava-এর Preconditions ক্লাস ইনপুট যাচাই করতে সাহায্য করে। এটি নিশ্চিত করে যে ইনপুট সঠিক না হলে অবিলম্বে IllegalArgumentException বা NullPointerException এর মতো ব্যতিক্রম (exception) তৈরি হবে।

@Test
void testPreconditions() {
    assertThrows(IllegalArgumentException.class, () -> {
        int value = Preconditions.checkArgument(-1 > 0, "Value must be positive");
    });
}
Copy

২. Immutable Collections for Stability

Guava-এর Immutable Collections ব্যবহার করলে ডেটা পরিবর্তন এড়ানো যায়, যা টেস্টের সময় স্থিতিশীল ফলাফল দেয়।

@Test
void testImmutableCollection() {
    ImmutableList<String> immutableList = ImmutableList.of("A", "B", "C");
    assertEquals(3, immutableList.size());
    assertThrows(UnsupportedOperationException.class, () -> {
        immutableList.add("D");
    });
}
Copy

৩. Utilities for Mocking and Validation

Guava-এর কিছু ক্লাস যেমন Objects, Strings, এবং MoreObjects সহজে মান যাচাই করতে বা মক ডেটা তৈরি করতে ব্যবহার করা যেতে পারে।

@Test
void testToStringHelper() {
    String result = MoreObjects.toStringHelper(this)
            .add("name", "Test")
            .add("age", 25)
            .toString();
    assertTrue(result.contains("name=Test"));
    assertTrue(result.contains("age=25"));
}
Copy

৪. Using Throwables for Exception Testing

Guava-এর Throwables ক্লাস exception handling এবং testing সহজ করে।

@Test
void testThrowables() {
    try {
        throw new IllegalArgumentException("Invalid argument");
    } catch (Exception e) {
        String stackTrace = Throwables.getStackTraceAsString(e);
        assertTrue(stackTrace.contains("IllegalArgumentException"));
    }
}
Copy

৫. Testing with Fluent APIs

Guava-এর Splitter এবং Joiner টেস্টিং ডেটার প্রস্তুতিতে সহায়ক:

@Test
void testStringUtilities() {
    List<String> result = Splitter.on(',').omitEmptyStrings().trimResults().splitToList(" A, B ,C ");
    assertEquals(3, result.size());
    assertEquals("A", result.get(0));
}
Copy

Debugging with Guava

১. Using MoreObjects.toStringHelper

toStringHelper ডিবাগিংয়ের সময় অবজেক্টের ডিটেল্ড বিবরণ প্রদর্শন করতে সহায়ক।

@Override
public String toString() {
    return MoreObjects.toStringHelper(this)
            .add("name", "TestObject")
            .add("id", 101)
            .toString();
}
Copy

ডিবাগিংয়ে এর আউটপুট:

TestObject{name=TestObject, id=101}
Copy

২. Logging with Guava’s Stopwatch

Performance debugging-এর জন্য Guava-এর Stopwatch ক্লাস কার্যকর। এটি কার্যক্রমের সময় পরিমাপ করে।

@Test
void testStopwatch() throws InterruptedException {
    Stopwatch stopwatch = Stopwatch.createStarted();
    Thread.sleep(500); // Simulate delay
    stopwatch.stop();
    assertTrue(stopwatch.elapsed(TimeUnit.MILLISECONDS) >= 500);
}
Copy

৩. Handling Exceptions with Throwables

Throwables.getCausalChain() ব্যবহার করে exception chain ডিবাগ করতে পারবেন।

@Test
void testCausalChain() {
    try {
        throw new RuntimeException("Root cause", new IllegalArgumentException("Illegal argument"));
    } catch (Exception e) {
        List<Throwable> causalChain = Throwables.getCausalChain(e);
        assertEquals(2, causalChain.size());
    }
}
Copy

৪. Caching Debugging Data

Guava-এর Cache ব্যবহার করে ডিবাগিং ডেটা দ্রুত সংগৃহীত এবং পুনরায় ব্যবহার করা যায়।

@Test
void testCacheForDebugging() throws ExecutionException {
    LoadingCache<String, String> cache = CacheBuilder.newBuilder()
            .maximumSize(100)
            .build(new CacheLoader<>() {
                public String load(String key) {
                    return "DebugValue";
                }
            });
    assertEquals("DebugValue", cache.get("testKey"));
}
Copy

৫. Monitoring Concurrent Operations

ListenableFuture এবং Futures ব্যবহার করে ডিবাগিংয়ের সময় asynchronous কার্যকলাপ পর্যবেক্ষণ করা যায়।

@Test
void testListenableFutureDebugging() throws Exception {
    ListeningExecutorService service = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(2));
    ListenableFuture<Integer> future = service.submit(() -> 10);
    future.addListener(() -> System.out.println("Task Completed"), MoreExecutors.directExecutor());
    assertEquals(10, (int) future.get());
}
Copy

Best Practices for Testing and Debugging with Guava

1. Use Immutable Objects: টেস্টিং এবং ডিবাগিং-এর জন্য স্থিতিশীল ডেটা তৈরি করুন।
2. Enable Logging: Stopwatch এবং MoreObjects-এর মতো ক্লাস ব্যবহার করে কার্যক্রম পর্যবেক্ষণ করুন।
3. Simplify Exception Handling: Throwables ব্যবহার করে exception স্ট্যাকট্রেস সহজে বিশ্লেষণ করুন।
4. Use Fluent APIs: টেস্ট কেস সংক্ষিপ্ত এবং সহজবোধ্য করতে Fluent APIs ব্যবহার করুন।
5. Cache Debugging Data: লোডিং এবং পুনঃব্যবহারযোগ্য ডেটার জন্য Guava ক্যাশ ব্যবহার করুন।

Guava টেস্টিং এবং ডিবাগিংয়ের জন্য কার্যকরী টুলস সরবরাহ করে, যা Java অ্যাপ্লিকেশন ডেভেলপমেন্টে সময় বাঁচায় এবং উন্নত মান নিশ্চিত করে। Guava-এর লাইটওয়েট এবং সহজ API আপনার কাজকে দ্রুত এবং নির্ভুল করতে সহায়ক।

Google Guava লাইব্রেরি Java-তে Collections এবং Utilities ব্যবহারে সুবিধা প্রদান করে। Guava-এর জন্য Unit Testing করায় নিশ্চিত হওয়া যায় যে কোড সঠিকভাবে কাজ করছে এবং প্রত্যাশিত ফলাফল দিচ্ছে। নিচে Guava-ভিত্তিক Unit Testing-এর কিছু গুরুত্বপূর্ণ টেকনিক আলোচনা করা হলো:

1. Guava Collections-এর জন্য Unit Testing

Immutable Collections Test

Guava-এর ImmutableList, ImmutableMap, ইত্যাদি নিশ্চিত করে যে এগুলো পরিবর্তনযোগ্য নয়। Unit Test দিয়ে এটি যাচাই করা যেতে পারে।

import com.google.common.collect.ImmutableList;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

class GuavaImmutableTest {
    @Test
    void testImmutableList() {
        ImmutableList<String> list = ImmutableList.of("A", "B", "C");
        
        // নিশ্চিত করুন লিস্টে ডেটা সঠিক
        assertEquals(3, list.size());
        assertTrue(list.contains("A"));
        
        // পরিবর্তন করার চেষ্টা করলে Exception হবে
        assertThrows(UnsupportedOperationException.class, () -> list.add("D"));
    }
}
Copy

Multimap Testing

Guava-এর Multimap একাধিক ভ্যালুকে একক কী-তে ম্যাপ করতে সক্ষম। এটি সঠিকভাবে কাজ করছে কি না তা নিশ্চিত করতে Unit Test ব্যবহার করা হয়।

import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.Multimap;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

class GuavaMultimapTest {
    @Test
    void testMultimap() {
        Multimap<String, String> multimap = ArrayListMultimap.create();
        multimap.put("fruit", "apple");
        multimap.put("fruit", "orange");
        multimap.put("vegetable", "carrot");
        
        assertEquals(2, multimap.get("fruit").size());
        assertTrue(multimap.get("fruit").contains("apple"));
        assertEquals(1, multimap.get("vegetable").size());
    }
}
Copy

2. Caching Features-এর Unit Testing

Guava-এর Cache API ব্যবহার করে ডেটা ক্যাশিং কার্যকারিতা নিশ্চিত করার জন্য Unit Test প্রয়োজন।

import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
import org.junit.jupiter.api.Test;

import java.util.concurrent.TimeUnit;

import static org.junit.jupiter.api.Assertions.*;

class GuavaCacheTest {
    @Test
    void testCache() throws InterruptedException {
        Cache<String, String> cache = CacheBuilder.newBuilder()
                .expireAfterWrite(1, TimeUnit.SECONDS)
                .build();

        cache.put("key", "value");
        assertEquals("value", cache.getIfPresent("key"));

        // ক্যাশ মেয়াদ শেষ হওয়ার পরে পরীক্ষা
        Thread.sleep(1100);
        assertNull(cache.getIfPresent("key"));
    }
}
Copy

3. Optional Testing

Guava-এর Optional NullPointerException প্রতিরোধ করতে ব্যবহৃত হয়। এটি সঠিকভাবে কাজ করছে কি না তা Unit Test-এ যাচাই করা হয়।

import com.google.common.base.Optional;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

class GuavaOptionalTest {
    @Test
    void testOptional() {
        Optional<String> present = Optional.of("Hello");
        Optional<String> absent = Optional.absent();

        assertTrue(present.isPresent());
        assertEquals("Hello", present.get());

        assertFalse(absent.isPresent());
        assertThrows(IllegalStateException.class, absent::get);
    }
}
Copy

4. Preconditions Testing

Guava-এর Preconditions ক্লাস Argument Validation-এর জন্য ব্যবহৃত হয়। এটি Unit Test দিয়ে নিশ্চিত করা যায়।

import com.google.common.base.Preconditions;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

class GuavaPreconditionsTest {
    @Test
    void testPreconditions() {
        int x = 10;
        int y = 0;

        // শর্ত সঠিক থাকলে চলে যাবে
        Preconditions.checkArgument(x > 0);

        // শর্ত ভঙ্গ হলে Exception হবে
        assertThrows(IllegalArgumentException.class, () -> Preconditions.checkArgument(y > 0));
    }
}
Copy

5. Utility Methods Testing

Guava-এর বিভিন্ন Utility Methods যেমন Strings, Lists, ইত্যাদির জন্য Unit Testing করা হয়।

import com.google.common.base.Strings;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

class GuavaUtilityTest {
    @Test
    void testStrings() {
        assertTrue(Strings.isNullOrEmpty(null));
        assertTrue(Strings.isNullOrEmpty(""));

        assertFalse(Strings.isNullOrEmpty("text"));

        assertEquals("0001", Strings.padStart("1", 4, '0'));
    }
}
Copy

6. Parameterized Testing

JUnit-এর Parameterized Testing ব্যবহার করে Guava-এর বিভিন্ন ইনপুট ও আউটপুট যাচাই করা যায়।

import com.google.common.collect.ImmutableList;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;

import static org.junit.jupiter.api.Assertions.*;

class GuavaParameterizedTest {
    @ParameterizedTest
    @ValueSource(strings = {"A", "B", "C"})
    void testImmutableListContains(String input) {
        ImmutableList<String> list = ImmutableList.of("A", "B", "C");
        assertTrue(list.contains(input));
    }
}
Copy

7. Exception Handling Testing

Guava ব্যবহারকালে যে Exception হতে পারে তা সঠিকভাবে Test করতে হবে।

import com.google.common.collect.ImmutableList;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

class GuavaExceptionTest {
    @Test
    void testException() {
        ImmutableList<String> list = ImmutableList.of("A", "B", "C");

        assertThrows(IndexOutOfBoundsException.class, () -> list.get(5));
    }
}
Copy

Guava-এর Unit Testing করার সময় JUnit বা TestNG-এর মতো ফ্রেমওয়ার্ক ব্যবহার করে Test Case লিখতে পারেন। এই টেকনিকগুলো ব্যবহার করে আপনি Guava ভিত্তিক কোডের কার্যকারিতা এবং স্থায়িত্ব নিশ্চিত করতে পারবেন।

গুয়াভা (Guava) লাইব্রেরির Cache এবং EventBus কম্পোনেন্টগুলোর জন্য সঠিকভাবে টেস্টিং করা গুরুত্বপূর্ণ। এটির মাধ্যমে নিশ্চিত করা যায় যে এই ফিচারগুলো প্রত্যাশিতভাবে কাজ করছে এবং সঠিক পারফরম্যান্স নিশ্চিত করছে।

Guava Cache-এর জন্য Testing

Guava Cache একটি ইন-মেমোরি ক্যাশ সমাধান। এর কার্যকারিতা যাচাই করার জন্য নিচের ধাপগুলো অনুসরণ করা যেতে পারে।

1. Cache Data Loading Test

• নিশ্চিত করুন যে ক্যাশে কোনো ডেটা না থাকলে এটি সঠিকভাবে ডেটা লোড করছে।

• উদাহরণ:

  @Test
  public void testCacheLoading() throws ExecutionException {
      LoadingCache<String, String> cache = CacheBuilder.newBuilder()
              .maximumSize(100)
              .build(new CacheLoader<String, String>() {
                  @Override
                  public String load(String key) {
                      return "Value for " + key;
                  }
              });
  
      assertEquals("Value for key1", cache.get("key1"));
      assertEquals("Value for key2", cache.get("key2"));
  }
  Copy

2. Eviction Test

• ক্যাশ থেকে এন্ট্রি মুছে ফেলার ফিচারটি সঠিকভাবে কাজ করছে কিনা তা যাচাই করুন।

  @Test
  public void testCacheEviction() throws InterruptedException {
      Cache<String, String> cache = CacheBuilder.newBuilder()
              .expireAfterWrite(2, TimeUnit.SECONDS)
              .build();
  
      cache.put("key1", "value1");
      Thread.sleep(3000); // Wait for eviction
  
      assertNull(cache.getIfPresent("key1"));
  }
  Copy

3. Maximum Size Constraint Test

• নিশ্চিত করুন ক্যাশে নির্দিষ্ট সাইজের বেশি এন্ট্রি না থাকে।

  @Test
  public void testCacheMaximumSize() {
      Cache<String, String> cache = CacheBuilder.newBuilder()
              .maximumSize(2)
              .build();
  
      cache.put("key1", "value1");
      cache.put("key2", "value2");
      cache.put("key3", "value3");
  
      assertNull(cache.getIfPresent("key1")); // Oldest entry should be evicted
      assertNotNull(cache.getIfPresent("key2"));
      assertNotNull(cache.getIfPresent("key3"));
  }
  Copy

4. Cache Statistics Test

• ক্যাশ স্ট্যাটিস্টিক্স মনিটর করুন।

  @Test
  public void testCacheStatistics() throws ExecutionException {
      Cache<String, String> cache = CacheBuilder.newBuilder()
              .recordStats()
              .build();
  
      cache.put("key1", "value1");
      cache.getIfPresent("key1");
      cache.getIfPresent("key2"); // Cache miss
  
      CacheStats stats = cache.stats();
      assertEquals(1, stats.hitCount());
      assertEquals(1, stats.missCount());
  }
  Copy

EventBus-এর জন্য Testing

Guava-এর EventBus কম্পোনেন্ট একটি ইভেন্ট ডেলিভারি সিস্টেম। এটি ইভেন্ট সাবস্ক্রাইবারদের কাছে সঠিকভাবে ইভেন্ট পৌঁছাচ্ছে কিনা তা টেস্ট করা গুরুত্বপূর্ণ।

1. Event Delivery Test

• ইভেন্ট সাবস্ক্রাইবারকে সঠিকভাবে পৌঁছানো হচ্ছে কিনা তা যাচাই করুন।

  public class EventReceiver {
      private String message;
  
      @Subscribe
      public void receiveEvent(String event) {
          this.message = event;
      }
  
      public String getMessage() {
          return message;
      }
  }
  
  @Test
  public void testEventDelivery() {
      EventBus eventBus = new EventBus();
      EventReceiver receiver = new EventReceiver();
      eventBus.register(receiver);
  
      eventBus.post("Hello, EventBus!");
      assertEquals("Hello, EventBus!", receiver.getMessage());
  }
  Copy

2. Multiple Subscriber Test

• একাধিক সাবস্ক্রাইবার সঠিকভাবে কাজ করছে কিনা তা যাচাই করুন।

  public class ReceiverA {
      private String message;
  
      @Subscribe
      public void handleEvent(String event) {
          this.message = "ReceiverA: " + event;
      }
  
      public String getMessage() {
          return message;
      }
  }
  
  public class ReceiverB {
      private String message;
  
      @Subscribe
      public void handleEvent(String event) {
          this.message = "ReceiverB: " + event;
      }
  
      public String getMessage() {
          return message;
      }
  }
  
  @Test
  public void testMultipleSubscribers() {
      EventBus eventBus = new EventBus();
      ReceiverA receiverA = new ReceiverA();
      ReceiverB receiverB = new ReceiverB();
  
      eventBus.register(receiverA);
      eventBus.register(receiverB);
  
      eventBus.post("Event for all");
  
      assertEquals("ReceiverA: Event for all", receiverA.getMessage());
      assertEquals("ReceiverB: Event for all", receiverB.getMessage());
  }
  Copy

3. Exception Handling Test

• সাবস্ক্রাইবারে কোনো এক্সেপশন ঘটলে ইভেন্ট বাসের কার্যকারিতা ক্ষতিগ্রস্ত হচ্ছে কিনা তা যাচাই করুন।

  public class FaultySubscriber {
      @Subscribe
      public void handleEvent(String event) {
          throw new RuntimeException("Error in subscriber");
      }
  }
  
  @Test
  public void testExceptionHandling() {
      EventBus eventBus = new EventBus();
      FaultySubscriber subscriber = new FaultySubscriber();
      eventBus.register(subscriber);
  
      try {
          eventBus.post("Test event");
      } catch (Exception e) {
          fail("EventBus should not throw an exception");
      }
  }
  Copy

Guava Cache এবং EventBus-এর জন্য সঠিকভাবে টেস্টিং করলে অ্যাপ্লিকেশনের স্থায়িত্ব এবং পারফরম্যান্স উন্নত হয়। উপরের টেস্ট কেসগুলো ডেভেলপমেন্ট প্রক্রিয়ায় অন্তর্ভুক্ত করে সহজেই বাগ এবং অনাকাঙ্ক্ষিত আচরণ এড়ানো সম্ভব।

Guava লাইব্রেরি Java-তে উন্নত কালেকশন এবং Optional ব্যবহারে একটি শক্তিশালী সমাধান দেয়। এটি Debugging সহজতর করতে কিছু কার্যকর ফিচার সরবরাহ করে। নিচে Guava Collections এবং Optional এর ব্যবহারে Debugging-এর উপায় নিয়ে আলোচনা করা হলো:

Guava Collections Debugging

Guava Collections হলো Java Collections Framework (JCF)-এর একটি সমৃদ্ধ এক্সটেনশন যা Immutable, Multiset, Multimap, এবং BiMap-এর মতো উন্নত ডেটা স্ট্রাকচার সরবরাহ করে। Debugging সহজ করার জন্য এই ফিচারগুলো কার্যকর:

১. Immutable Collections

Immutable Collections অপরিবর্তনীয় হওয়ায় ডিবাগিং সহজ হয় কারণ এদের কোনো পরিবর্তন সম্ভব নয়। এটি অনিচ্ছাকৃত পরিবর্তনের সম্ভাবনা দূর করে।

• Debugging সুবিধা:

  ImmutableList<String> list = ImmutableList.of("Apple", "Banana", "Cherry");
  System.out.println(list); // Output: [Apple, Banana, Cherry]
  Copy

• Immutable Collections ব্যবহার করলে Runtime Exception দ্রুত পাওয়া যায়, যেমন:

  list.add("Mango"); // Throws UnsupportedOperationException
  Copy

২. Multiset Debugging

Multiset একটি কালেকশন যেখানে একটি আইটেম একাধিকবার উপস্থিত থাকতে পারে। এটি আইটেম কাউন্ট সহজে দেখতে সহায়ক।

• Debugging উদাহরণ:

  Multiset<String> multiset = HashMultiset.create();
  multiset.add("Apple");
  multiset.add("Apple");
  multiset.add("Banana");
  
  System.out.println(multiset); // Output: [Apple x 2, Banana]
  System.out.println(multiset.count("Apple")); // Output: 2
  Copy

৩. Multimap Debugging

Multimap একাধিক মান এক কীর্তির (Key) সঙ্গে সংযুক্ত করতে ব্যবহৃত হয়।

• Debugging উদাহরণ:

  Multimap<String, String> multimap = ArrayListMultimap.create();
  multimap.put("Fruit", "Apple");
  multimap.put("Fruit", "Banana");
  multimap.put("Vegetable", "Carrot");
  
  System.out.println(multimap); // Output: {Fruit=[Apple, Banana], Vegetable=[Carrot]}
  System.out.println(multimap.get("Fruit")); // Output: [Apple, Banana]
  Copy

৪. BiMap Debugging

BiMap একদিকে কী এবং অন্যদিকে মান উভয়ের জন্য ইউনিক বাধ্যবাধকতা দেয়।

• Debugging সুবিধা:

  BiMap<String, Integer> biMap = HashBiMap.create();
  biMap.put("One", 1);
  biMap.put("Two", 2);
  
  System.out.println(biMap); // Output: {One=1, Two=2}
  System.out.println(biMap.inverse().get(1)); // Output: One
  Copy

Guava Optional Debugging

Guava-এর Optional ক্লাস NullPointerException প্রতিরোধে কার্যকর এবং Debugging সহজ করে তোলে। এটি null-কে সরাসরি ব্যবহারের পরিবর্তে একটি encapsulated container প্রদান করে।

১. NullPointerException Debugging এ সহায়ক

• Optional তৈরি:

  Optional<String> optional = Optional.of("Hello");
  System.out.println(optional.get()); // Output: Hello
  Copy

• Empty Optional ডিবাগিং:

  Optional<String> emptyOptional = Optional.absent();
  System.out.println(emptyOptional.isPresent()); // Output: false
  Copy

২. Debugging Optional Values

Optional ক্লাস isPresent() মেথড দিয়ে কন্টেইনার চেক করার সুযোগ দেয় এবং or() মেথড ডিফল্ট মান দিতে পারে।

• Debugging উদাহরণ:

  Optional<String> optional = Optional.fromNullable(null);
  
  if (optional.isPresent()) {
      System.out.println(optional.get());
  } else {
      System.out.println("Value is absent");
  }
  // Output: Value is absent
  Copy

• ডিফল্ট মান Debugging:

  String value = optional.or("Default Value");
  System.out.println(value); // Output: Default Value
  Copy

৩. Transform এবং Chaining Debugging

Optional-এর transform() এবং or() মেথড ব্যবহার করে চেইনড অপারেশন Debugging করা সহজ হয়।

• Debugging উদাহরণ:

  Optional<Integer> number = Optional.of(5);
  
  String result = number.transform(num -> "Number: " + num).or("No Number");
  System.out.println(result); // Output: Number: 5
  Copy

Guava Collections এবং Optional ক্লাস Java প্রোগ্রামিংয়ে Debugging সহজ করে তোলে। Immutable Collections পরিবর্তনযোগ্য নয় বলে নির্ভুল ট্র্যাকিং নিশ্চিত করে, এবং Optional NullPointerException প্রতিরোধে সাহায্য করে। এভাবে, Guava ব্যবহার করলে ডেটা ম্যানেজমেন্ট এবং ত্রুটি নির্ণয় উভয়ই সহজতর হয়।

Guava ব্যবহার করে Mockito এবং JUnit এর মাধ্যমে Java কোডের টেস্টিং আরও সহজ এবং কার্যকর করা যায়। এটি বিশেষত Immutable Collections, Optional, এবং Cache এর মত Guava এর উপাদানগুলোর টেস্টিংয়ের জন্য উপযোগী।

নিচে Mockito এবং JUnit এর সাথে Guava একত্রে ব্যবহারের জন্য বিস্তারিত আলোচনা দেওয়া হলো:

Guava এবং Mockito Integration

1. Immutable Collections Mock করা

Guava এর Immutable Collections সরাসরি Mockito এর সাথে ব্যবহার করা সম্ভব।

উদাহরণ:

@Test
void testImmutableList() {
    List<String> mockList = mock(List.class);
    when(mockList.size()).thenReturn(3);
    when(mockList.get(0)).thenReturn("A");
    when(mockList.get(1)).thenReturn("B");
    when(mockList.get(2)).thenReturn("C");

    ImmutableList<String> immutableList = ImmutableList.copyOf(mockList);
    assertEquals(3, immutableList.size());
    assertEquals("A", immutableList.get(0));
}
Copy

পয়েন্ট: Mock করা Data থেকে Immutable Collection তৈরি করলে Guava এর কনসেপ্ট ঠিক থাকে এবং এটি Test Cases-এ নিরাপদ থাকে।

2. Optional Mock করা

Guava এর Optional এর জন্য Mockito এর when() এবং thenReturn() ব্যবহার করে সহজে টেস্টিং করা যায়।

উদাহরণ:

@Test
void testOptional() {
    Service mockService = mock(Service.class);
    when(mockService.getData()).thenReturn(Optional.of("Mocked Data"));

    Optional<String> data = mockService.getData();
    assertTrue(data.isPresent());
    assertEquals("Mocked Data", data.get());
}

interface Service {
    Optional<String> getData();
}
Copy

পয়েন্ট: Optional এর মাধ্যমে NullPointerException এড়িয়ে Mockito ব্যবহার আরও কার্যকর করা যায়।

3. Preconditions এর সাথে Mockito

Guava এর Preconditions ক্লাস এবং Mockito একত্রে ব্যবহার করে Input Validation এর জন্য Behavior নিশ্চিত করা যায়।

উদাহরণ:

@Test
void testPreconditions() {
    Service mockService = mock(Service.class);
    doThrow(new IllegalArgumentException("Invalid Input"))
        .when(mockService)
        .process(Preconditions.checkNotNull(null));

    assertThrows(IllegalArgumentException.class, () -> mockService.process(null));
}

interface Service {
    void process(String input);
}
Copy

Guava এবং JUnit Integration

1. JUnit এর মাধ্যমে Immutable Collections টেস্ট করা

Immutable Collections ব্যবহারের জন্য JUnit Assertions ব্যবহার করা যেতে পারে।

উদাহরণ:

@Test
void testImmutableMap() {
    ImmutableMap<String, Integer> map = ImmutableMap.of("A", 1, "B", 2, "C", 3);
    assertEquals(3, map.size());
    assertTrue(map.containsKey("A"));
    assertEquals(1, map.get("A"));
}
Copy

2. Optional এর Presence এবং Value টেস্ট করা

Guava Optional টেস্ট করার জন্য JUnit Assertions সরাসরি ব্যবহার করা যায়।

উদাহরণ:

@Test
void testOptionalWithJUnit() {
    Optional<String> optional = Optional.of("Hello, Guava");
    assertTrue(optional.isPresent());
    assertEquals("Hello, Guava", optional.get());
}
Copy

3. Guava Cache টেস্টিং

Guava এর CacheBuilder ব্যবহার করলে Caching Behavior সহজে টেস্ট করা যায়।

উদাহরণ:

@Test
void testCache() {
    Cache<String, String> cache = CacheBuilder.newBuilder()
        .maximumSize(100)
        .expireAfterWrite(10, TimeUnit.MINUTES)
        .build();

    cache.put("key1", "value1");
    assertEquals("value1", cache.getIfPresent("key1"));

    cache.invalidate("key1");
    assertNull(cache.getIfPresent("key1"));
}
Copy

4. FluentIterable এর জন্য টেস্ট

Guava এর FluentIterable এর উপর JUnit ব্যবহার করে Filtering Behavior টেস্ট করা যায়।

উদাহরণ:

@Test
void testFluentIterable() {
    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
    FluentIterable<Integer> filtered = FluentIterable.from(numbers)
        .filter(n -> n % 2 == 0);

    List<Integer> expected = Arrays.asList(2, 4);
    assertEquals(expected, filtered.toList());
}
Copy

Mockito এবং JUnit এর সমন্বয়ে Guava টেস্টিং

Mockito এবং JUnit একত্রে ব্যবহার করলে Behavior এবং Integration Testing আরও কার্যকর হয়।

উদাহরণ:

Guava Cache Mock এবং Integration Test:

@Test
void testServiceWithCache() {
    Cache<String, String> mockCache = mock(Cache.class);
    when(mockCache.getIfPresent("key")).thenReturn("Mocked Value");

    Service service = new Service(mockCache);
    String value = service.getValue("key");
    assertEquals("Mocked Value", value);
}

class Service {
    private final Cache<String, String> cache;

    Service(Cache<String, String> cache) {
        this.cache = cache;
    }

    String getValue(String key) {
        return cache.getIfPresent(key);
    }
}
Copy

Guava এর সাথে Mockito এবং JUnit Integration টেস্টিংয়ের জন্য একটি শক্তিশালী পরিবেশ তৈরি করে। Immutable Collections, Optional, Cache, এবং FluentIterable এর টেস্টিং করা সহজ হয়। সঠিক টেস্ট কৌশল অবলম্বন করলে আপনার প্রজেক্ট উন্নতমানের এবং কম ত্রুটিযুক্ত হবে।